Combined QLC Programming Method

ABSTRACT

The present disclosure generally relates to improved foggy-fine programming. The data to be written initially passes through an encoder before being written to SLC. While the data is being written to SLC, the data also passes through DRAM before going through the encoder to prepare for fine writing. The data that is to be stored in SLC is in latches in the memory device and is then written to MLC as a foggy write. Thereafter, the data that has passed through the encoder is fine written to MLC. The programming occurs in a staggered fashion where the ratio of SLC:foggy:fine writing is 4:1:1. To ensure sufficient XOR context management, programming across multiple dies, as well as across multiple super-devices, is staggered so that only four XOR parity context are necessary across 64 dies.

BACKGROUND OF THE DISCLOSURE Field of the Disclosure

Embodiments of the present disclosure generally relate to improvingfoggy-fine writing to QLC.

Description of the Related Art

Programming or writing data may require two writing phases: foggy andfine. In foggy-fine programming, the bits to be written cannot simply bewritten once. Rather, the data needs to be first written by foggyprogramming where voltage pulses are provided to push the current stateto a more resolved state, but not completely resolved state. Fineprogramming is performed at a point in time after foggy programming towrite the data again in the completely resolved state.

In foggy-fine programming, there is a four page transfer for foggyprogramming and a four page transfer for fine programming for a 128 KBtransfer in total for a two-plane device. The foggy state is unreadable,and the data needs to be protected in case of a possible power lossevent (PLI). Additionally, foggy-fine programming occurs in a staggeredword line sequence, which means that data in transit is five times oreight times the programmable unit of 128 KB. To perform foggy-fineprogramming, multiple megabytes may be programmed multiple times. Toperform the multiple programming, a large amount of data needs to be setaside in order to perform repeat programming with the exact same data.

Therefore, there is a need in the art for improved foggy-fineprogramming.

SUMMARY OF THE DISCLOSURE

The present disclosure generally relates to improved foggy-fineprogramming. The data to be written initially passes through an encoderbefore being written to SLC. While the data is being written to SLC, thedata also passes through DRAM before going through the encoder toprepare for fine writing. The data that is to be stored in SLC is inlatches in the memory device and is then written to MLC as a foggywrite. Thereafter, the data that has passed through the encoder is finewritten to MLC. The programming occurs in a staggered fashion where theratio of SLC:foggy:fine writing is 4:1:1. To ensure sufficient XORcontext management, programming across multiple dies, as well as acrossmultiple super-devices, is staggered so that only four XOR paritycontext are necessary across 64 dies.

In one embodiment, data storage device comprises: one or more memorydevices, the one or more memory devices including SLC memory and MLCmemory; and a controller coupled to the one or more memory devices, thecontroller configured to: write data to the SLC memory; foggy write thedata to MLC memory, wherein the foggy writing the data to the MLC memoryincludes retrieving the data from latches in the one or more memorydevices and writing the retrieved data to the MLC memory; and finewriting the data to the MLC memory.

In another embodiment, a data storage device comprises: one or morememory devices, the one or more memory devices each including aplurality of dies with each die including SLC memory and MLC memory; anda controller coupled to the one or more memory devices, the controllerconfigured to: stagger writing to the SLC memory, foggy writing to theMLC memory, and fine writing to the MLC memory, wherein a ratio ofwriting to the SLC memory to foggy writing to the MLC memory to finewriting to the MLC memory is 4:1:1.

In another embodiment, a data storage device comprises: one or morememory devices, wherein each memory device has a plurality of dies,wherein the plurality of dies are arranged into four strings, whereinthe one or more memory devices each include SLC memory and MLC memory; acontroller coupled to the one or more memory devices, the controllerconfigured to: write data to the SLC memory of a first string on a firstword line for a first set of dies; foggy write data to the MLC memory ofthe first string on the first word line for the first set of dies; writedata to the SLC memory of a second string on the first word line for thefirst set of dies; foggy write data to the MLC memory of the secondstring on the first word line for the first set of dies; write data tothe SLC memory of a third string on the first word line for the firstset of dies; foggy write data to the MLC memory of the third string onthe first word line for the first set of dies; write data to the SLCmemory of the first string on the first word line for a second set ofdies different from the first set of dies; foggy write data to the MLCmemory of the first string on the first word line for the second set ofdies; write data to the SLC memory of a fourth string on the first wordline for the first set of dies; and foggy write data to the MLC memoryof the fourth string on the first word line for the first set of dies.It is to be understood that the writing may occur in a different orderthan discussed above. Specifically, it is to be understood that thewriting order dictates how many word lines will be in the foggy stateprior to being written in the fine state.

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above recited features of the presentdisclosure can be understood in detail, a more particular description ofthe disclosure, briefly summarized above, may be had by reference toembodiments, some of which are illustrated in the appended drawings. Itis to be noted, however, that the appended drawings illustrate onlytypical embodiments of this disclosure and are therefore not to beconsidered limiting of its scope, for the disclosure may admit to otherequally effective embodiments.

FIG. 1 is a schematic illustration of a system for storing dataaccording to one embodiment.

FIGS. 2A-2C are schematic illustrations of scheduling foggy-fineprogramming according to various embodiments.

FIG. 3 is a chart illustrating staggering foggy-fine programming.

FIGS. 4A-4C are collectively a schematic illustration showing aprogramming ratio of SLC:foggy:fine according to one embodiment.

FIGS. 5A-5C are collectively a schematic illustration showing foggy-fineprogramming for a single super-device.

FIGS. 6A-6C are collectively a schematic illustration showing foggy-fineprogramming for multiple super-devices.

To facilitate understanding, identical reference numerals have beenused, where possible, to designate identical elements that are common tothe figures. It is contemplated that elements disclosed in oneembodiment may be beneficially utilized on other embodiments withoutspecific recitation.

DETAILED DESCRIPTION

In the following, reference is made to embodiments of the disclosure.However, it should be understood that the disclosure is not limited tospecific described embodiments. Instead, any combination of thefollowing features and elements, whether related to differentembodiments or not, is contemplated to implement and practice thedisclosure. Furthermore, although embodiments of the disclosure mayachieve advantages over other possible solutions and/or over the priorart, whether or not a particular advantage is achieved by a givenembodiment is not limiting of the disclosure. Thus, the followingaspects, features, embodiments and advantages are merely illustrativeand are not considered elements or limitations of the appended claimsexcept where explicitly recited in a claim(s). Likewise, reference to“the disclosure” shall not be construed as a generalization of anyinventive subject matter disclosed herein and shall not be considered tobe an element or limitation of the appended claims except whereexplicitly recited in a claim(s).

The present disclosure generally relates to improved foggy-fineprogramming. The data to be written initially passes through an encoderbefore being written to SLC. While the data is being written to SLC, thedata also passes through DRAM before going through the encoder toprepare for fine writing. The data that is to be stored in SLC is inlatches in the memory device and is then written to MLC as a foggywrite. Thereafter, the data that has passed through the encoder is finewritten to MLC. The programming occurs in a staggered fashion where theratio of SLC:foggy:fine writing is 4:1:1. To ensure sufficient XORcontext management, programming across multiple dies, as well as acrossmultiple super-devices, is staggered so that only four XOR paritycontext are necessary across 64 dies.

FIG. 1 is a schematic illustration of a system 100 for storing dataaccording to one embodiment. The system 100 for storing data accordingto one embodiment includes a host device 102 and a data storage device104. The host device 102 includes a dynamic random-access memory (DRAM)112. The host device 102 may include a wide range of devices, such ascomputer servers, network attached storage (NAS) units, desktopcomputers, notebook (i.e., laptop) computers, tablet computers (i.e.,“smart” pad), set-top boxes, telephone handsets (i.e., “smart” phones),televisions, cameras, display devices, digital media players, videogaming consoles, video streaming devices, and automotive applications(i.e., mapping, autonomous driving). In certain embodiments, host device102 includes any device having a processing unit or any form of hardwarecapable of processing data, including a general purpose processing unit,dedicated hardware (such as an application specific integrated circuit(ASIC)), configurable hardware such as a field programmable gate array(FPGA), or any other form of processing unit configured by softwareinstructions, microcode, or firmware.

The data storage device 104 communicates with the host device 102through an interface 106 included in the data storage device 104. Thedata storage device 104 includes a controller 108, a buffer 114, and oneor more memory devices 110. The data storage device 104 may be aninternal storage drive, such as a notebook hard drive or a desktop harddrive. Data storage device 104 may be a removable mass storage device,such as, but not limited to, a handheld, removable memory device, suchas a memory card (e.g., a secure digital (SD) card, a micro securedigital (micro-SD) card, or a multimedia card (MMC)) or a universalserial bus (USB) device. Data storage device 104 may take the form of anembedded mass storage device, such as an eSD/eMMC embedded flash drive,embedded in host device 102. Data storage device 104 may also be anyother type of internal storage device, removable storage device,embedded storage device, external storage device, or network storagedevice.

Memory device 110 may be, but is not limited to, internal or externalstorage units. The memory device 110 relies on a semiconductor memorychip, in which data can be stored as random-access memory (RAM),read-only memory (ROM), or other forms for RAM and ROM. RAM is utilizedfor temporary storage of data whereas ROM is utilized for storing datapermanently.

Data storage device 104 includes a controller 108 which managesoperations of data storage device 104, such as writes to or reads frommemory device 110. The controller 108 executes computer-readable programcode (e.g., software or firmware) executable instructions (hereinreferred to as “instructions”) for the transfer of data. Theinstructions may be executed by various components of controller 108such as processor, logic gates, switches, applications specificintegrated circuits (ASICs), programmable logic controllers embeddedmicrocontrollers, and other components of controller 108.

Data storage device 104 includes a buffer 114 which is a region ofphysical memory storage used to temporarily store data while the data isbeing moved from one place to another (i.e., from host device 102 tomemory device 110).

Data may be transferred to or from the DRAM 112 of the host device 102to the data storage device 104. One data transfer pathway may originatefrom the DRAM 112 of the host device 102 and communicate through theinterface 106 of the data storage device 104 to the controller 108. Thedata will then pass through the buffer 114 of the data storage device104 and be stored in the memory device 110. If the data is written to aSLC memory, then the data is simply written. If, however, the data iswritten to a MLC, such as a QLC memory, then a foggy-fine writingprocess occurs. It is to be noted that writing and programming may beused interchangeably throughout the disclosure. In one embodiment, thedata is first written to SLC memory and then moved to MLC memory. Inanother embodiment, all data is written to SLC cache first and thenmoved to QLC for sequential or non-repetitive writes. In such ascenario, the moving of the data to QLC is scheduled by the data storagedevice 204 as to create free space in SLC for the following writes fromthe host device 102. In another embodiment, repetitive write comprisesthe host rewriting recently written LBAs where recently means the datais still in SLC cache. In such a scenario, three possibilities exist:move all the data, including the old obsolete LBAs to QLC and createobsolete ‘holes”; move valid data only, skipping obsolete data in SLC;and if the amount of obsolete data is high, then compact SLC cache, do agarbage collection, without moving any data to QLC.

FIGS. 2A-2C are schematic illustrations of scheduling foggy-fineprogramming according to various embodiments. The Front End (FE) module202 comprises an XOR engine 204 and a static random-access memory (SRAM)206. Host data may be initially delivered to the FE module 202. The datapasses through the XOR engine 204 and is written to the SRAM 206. TheXOR engine 204 generates XOR parity information prior to writing to SRAM206. Exclusive OR (XOR) parity information is used to improvereliability of storage device for storing data, such as enabling datarecovery of failed writes or failed reads of data to and from NVM orenabling data recovery in case of power loss. The storage device may bethe data storage device 104 of FIG. 1. The reliability may be providedby using XOR parity information generated or computed based on datastored to storage device. The XOR engine 204 may generate a paritystream to be written to SRAM 206. SRAM 206 may contain a plurality ofdies in which data may be written to.

The Second Flash Manager (FM2) module 210 comprises of an encoder 212, aSRAM 216, and a decoder 214. The decoder 214 may comprise a low gear(LG) decoder and a high gear (HG) decoder. The LG decoder can implementlow power bit flipping algorithms, such as a low density parity check(LDPC) algorithm. The LG decoder may be operable to decode data andcorrect bit flips where such data has a low bit error rate (BER). The HGdecoder can implement full power decoding and error correctionalgorithms, which may be initiated upon a failure of the LG decoder todecode and correct bit flips in data. The HG decoder can be operable tocorrect bit flips where such data has a high BER. Alternatively, FM2 maybe replaced with a combined FE-FM monochip.

The encoder 212 and decoder 214 (including the LG decoder and HGdecoder) can include processing circuitry or a processor (with acomputer-readable medium that stores computer-readable program code(e.g., firmware) executable by the processor), logic circuitry, anapplication specific integrated circuit (ASIC), a programmable logiccontroller, an embedded microcontroller, a combination thereof, or thelike, for example. In some examples, the encoder 212 and the decoder 214are separate from the storage controller, and in other examples, theencoder 212 and the decoder 214 are embedded in or part of the storagecontroller. In some examples, the LG decoder is a hardened circuit, suchas logic circuitry, an ASIC, or the like. In some examples, the HGdecoder can be a soft decoder (e.g., implemented by a processor). Datamay be written to SRAM 216 after being decoded at the decoder 214. Thedata at SRAM 216 may be further delivered to the encoder 212, asdiscussed below.

The memory device may be a NAND memory device. The memory device 220 maycomprise of a SLC 222 and a MLC 224. It is to be understood that theembodiments discussed herein are applicable to any multilevel cell suchas MLC, TLC or QLC. MLC is simply exemplified. SLC 222, MLC, TLC, QLC,and PLC are named according to the number of bits that a memory cell mayaccept. For example, SLC may accept one bit per memory cell and QLC mayaccept four bits per memory cell. Each bit is registered on the storagedevice as a 1 or a 0. Additionally, while SLC memory is exemplified as amemory device, it is also contemplated that the SLC memory may bereplaced with a 2-bit cell or MLC memory device.

FIG. 2A is a schematic illustration of a foggy-fine writing process,according to one embodiment. Host data is fed to the FE module 202. Thehost data is sent through the XOR engine 204, and XOR parity informationis generated. The data is then written to the SRAM 206 at the FE module202. At the FM2 module 210, data is delivered to the encoder 212 fromthe SRAM 206 along stream 1. The data is then written to the SLC 222 ofthe memory device 220 along stream 2. To proceed with the foggy-finewriting to the MLC 224, the data is read from SLC 222 and then decodedat the decoder 214 of the FM2 module 210 along stream 3. The decodeddata is then written to the SRAM 216 of the FM2 module 210 in steam 4.The data is then send through the encoded 212 along stream 5 forencoding. The foggy write occurs after the data that is encoded at theencoder 212 of the FM2 module 210 from the SRAM 216 of the FM2 module210 along stream 6. The foggy write is the initial write from encoder212 of the FM2 module 210 to the MLC 224 of the memory device 220. Toproceed with the fine write, data is then read from SLC 222 anddelivered to the decoded 214 along stream 7. Following decoding, thedata is then written in SRAM along stream 8 and then delivered to theencoder 212 along stream 9 for encoding. The now encoded data is thenfine written to MLC 224 along stream 10.

According to the embodiment referred to in FIG. 2A, there may be noDRAM-bus traffic. Furthermore, the SLC and MLC programming may bede-coupled. The foggy-fine writing process may incorporate multi-streamwith direct write hot/cold sorting support. However, the bus traffic maybe higher.

FIG. 2B is a schematic illustration of a foggy-fine writing process,according to another embodiment. Host data is delivered to the FE module202. The host data passes through the XOR engine 204 and XOR parityinformation is generated. The data is then written to the SRAM 206 atthe FE module 202. From the SRAM 206 at the FE module, the data is thentransferred to the encoder 212 along stream 1. Once the data is encoded,the data is written to the SLC 222 along steam 2. Simultaneous withtransferring the data to the encoder 212 along stream 1, the data istransferred to the DRAM 230 along stream 3. The foggy-fine writingprocess involves first sending the data written to the DRAM 230 and thento the encoder 212 along stream 4 for encoding. The encoded data is thenfoggy written to MLC along stream 5. Thereafter, the data is again setfrom DRAM 230 to the encoder 212 along stream 6 for encoding. Followingencoding the data is then fine written along stream 7 to MLC 224. Thefoggy write step transfers the data from the DRAM 230 to the encoder 212and writes the data to the MLC 224. The fine write step occurs after thefoggy write step. The fine write step transfers the data from the DRAM230 to the encoder 212 and writes the data to the MLC 224. The SLC andMLC programs may occur in a sequential write process due to bufferlimitations.

FIG. 2C is a schematic illustration of a foggy-fine writing process,according to another embodiment. Host data is delivered to the FE module202. The host data passes through the XOR engine 204 and XOR parityinformation is generated. The data is then written to the SRAM 206 atthe FE module 202. From the SRAM 206 at the FE module, the data is thentransferred to the encoder 212 along stream 1 and then written to theSLC 222 along stream 2. The foggy write step writes the data from SLC222 to MLC 224. More specifically, the data is read from SLC 222 andthen foggy written to MLC 224 along stream 3. Concurrently with sendingthe data to the encoder 212, the data is transferred to the DRAM 230from SRAM 206 at the FE module 202 along stream 4. The fine write stepinvolves sending the data from DRAM 230 to the encoder 212 along stream5, along with XOR data, and then foggy writing the encoded data to MLC224 along stream 6. The data path using NAND data latches to stage databetween SLC and foggy programs, so that single 4-page data transfer maybe used for SLC and foggy MLC programs. The fine write may also occurfrom SLC 222 to MLC 224 after the foggy write in the case that theoriginal fine write becomes corrupted. The SLC and MLC programing mayoccur in a sequential write process due to buffer limitations.

FIG. 3 is a chart illustrating staggering foggy-fine programming. It isto be understood that the disclosure is not limited to the staggeredfoggy-fine programming exemplified in FIG. 3, but rather, othersequences are contemplated as well. More specifically, to performfoggy-fine programming, foggy programming along a word line for aparticular string cannot occur back-to-back. As shown in FIG. 3, toproperly foggy-fine write to word line 0 at string 0, several additionalwrites need to occur between the foggy write to word line 0, string 0and the fine write to word line 0, string 0. The foggy-fine writeprocess proceeds as follows.

Initially, data is foggy written to word line 0, string 0. Then, data isfoggy written to word line 0, string 1. Thereafter, data is foggywritten to word line 0, string 2. Then, data is foggy written to wordline 0, string 3. Thereafter, data is foggy written to word line 1,string 0. Now, finally, data can be fine written to word line 0, string0. The arrows in FIG. 3 illustrate the path of writing in the foggy-finewriting process. Basically, to properly foggy-fine write data, data isinitially foggy written to the specifically data location. Then, threeadditional foggy data writes occur to the same word line, but atdifferent strings. A fourth foggy write occurs in an adjacent word linealong the same string of the specific data location. Only after thefourth foggy write to the adjacent word line and same string may thefine writing to the original word line and original string (i.e., theoriginal data location) be performed. In total, four additional foggywrites occur prior to the fine writing.

FIGS. 4A-4C are collectively a schematic illustration showing aprogramming ratio of SLC:foggy:fine according to one embodiment. Ingeneral, SLC programming is significantly faster than foggy and fine MLC(or TLC or QLC) programs (i.e., about 10x difference). By staggeringwriting to the drive (e.g., utilizing single 4-page data transfer), theoverall transfers may be more consistent with little to no performanceloss and without throttling the data transfer (e.g., slowing down thehost transfers to artificially make the drive have a more consistentperformance). The ratio of (x)SLC:(y)foggy:(z)fine programs shouldgenerally be as close as possible to4*tPROG_(SLC):tPROG_(Foggy):tPROG_(Fine), where the value 4 reflects the1:4 density difference between SLC and QLC. This principle may beapplied to a different mix of NAND modes, such as MLC and TLC.

FIGS. 4A-4C show the staggering principle in a drive with three activesuper-devices comprising of 96-die each. Within each super-device, datamay be written to the various word lines, strings, and foggy/fineprogramming that may resemble the process outlined in FIG. 3.Furthermore, for every four writes (i.e., 4-page data transfer) to SLC(denoted by the small vertical bars associated adjacent the foggywrites), there is one foggy write to QLC or one fine write to QLC. Toensure smooth 2GB/s write performance, 2 MB of SLC data should bewritten every 1.5 ms.

FIGS. 5A-5C are collectively a schematic illustration showing foggy-fineprogramming for a single super-device. For each word line, 128 KB of XORcontext may be generated for each foggy program, and written to DRAM.FIG. 5 demonstrates the principle of sharing a limited number of paritycontexts to achieve the staggered scheduling of different program typesin a super-device. The limited number of parity contexts refers to thevalue of 4, which is the 1:4 density difference between SLC and QLC.Each parity group refers to a super-WL, which is a unit of all data inthe same WL-string in all devices. FIG. 5 may refer to the method inFIG. 3 to demonstrate the method for SLC/foggy-fine programming to asuper-device. After a string in a word line is at capacity, the XOR datais generated by the XOR engine, and the XOR engine is then available forgenerating XOR parity data for the next completed word line. Similar toFIG. 4, the staggering of the SLC-foggy-fine writing, and theproportions of 4:1:1 for writing, results in the four XOR generatorsbeing sufficient to provide the needed parity data by staggering theavailability of the XOR generators.

FIGS. 6A-6C are collectively a schematic illustration showing foggy-fineprogramming for multiple super-devices. The XOR context generated fromeach foggy program is unique to its own super device (i.e., there is noXOR relationship between super devices). A minimum time gap may berequired before starting a SLC/foggy write sequence on String 0 (i.e.,the initial write). The time gap may cause the host-write performance tobe more consistent. However, the minimum time gap may depend on thedrive capacity. Furthermore, to ensure a smooth performance, SLCprograms on the dies should not overlap within a super-device. To ensuresmooth 2 GB/s write performance, 2 MB of SLC data should be writtenevery 1.5 ms. An overlap of SLC programs may cause a performancebottleneck. Priority for data write is given to a WL that has alreadybeen utilized so that SLC writes may not overlap.

Fine data transfer occurs between about 400 μs to about 500 μs (with a400 MT/s TM bus). Furthermore, there may be one fine data transfer foreach 2 MB of SLC transfer/programming. The QLC fine data writes may notoverlap. In order to determine which fine data transfer occurs prior tothe other, the string number may be used. In general, the lower stringnumber will be transferred prior to the higher string number. In betweenQLC fine data transfers, a SLC write may occur in order to maintain amore consistent host performance.

The 4 page transfer limitation refers to the 4 XOR contexts that asingle super-device may require. In general, the next set of SLC/foggydies to program are determined by round-robin. Overall, the SLC write,foggy write, and fine write outlined in the embodiment may significantlyreduce data transfers over the NAND-bus and DRAM-bus. The reduced datatransfers may improve host write performance and may reduce device powerconsumption.

In one embodiment, data storage device comprises: one or more memorydevices, the one or more memory devices including SLC memory and MLCmemory; and a controller coupled to the one or more memory devices, thecontroller configured to: write data to the SLC memory; foggy write thedata to MLC memory, wherein the foggy writing the data to the MLC memoryincludes retrieving the data from latches in the one or more memorydevices and writing the retrieved data to the MLC memory; and finewriting the data to the MLC memory. The data that is finely written tothe MLC memory does not pass through the SLC memory. The data that isfinely written to the MLC memory passes through DRAM and an encoderbefore being finely written in the MLC memory. The data written to theSLC memory passes through an encoder. The data that is written to theSLC memory does not pass through the DRAM that the data finely writtento the MLC memory passes through. The data that is foggy written to theMLC memory does not pass through the DRAM that the data finely writtento the MLC memory passes through. A single four page transfer is usedfor both the writing the data to the SLC memory and foggy writing thedata to the MLC memory.

In another embodiment, a data storage device comprises: one or morememory devices, the one or more memory devices each including aplurality of dies with each die including SLC memory and MLC memory; anda controller coupled to the one or more memory devices, the controllerconfigured to: stagger writing to the SLC memory, foggy writing to theMLC memory, and fine writing to the MLC memory, wherein a ratio ofwriting to the SLC memory to foggy writing to the MLC memory to finewriting to the MLC memory is 4:1:1. Writing to the SLC memory occurs ononly one word line at a time for a given memory device of the one ormore memory devices. Foggy writing to the MLC memory occurs with formultiple word lines simultaneously. Simultaneous foggy writing occursfor different dies. The simultaneous foggy writing occurs for the samestring. The MLC memory is QLC memory. The controller is configured towrite data to the SLC memory of at least a first memory device of theone or more memory devices simultaneous with foggy writing data to theMLC memory of a second memory device of the one or more memory devicesand simultaneous with fine writing data to the MLC memory of at least athird memory device of the one or more memory devices.

In another embodiment, a data storage device comprises: one or morememory devices, wherein each memory device has a plurality of dies,wherein the plurality of dies are arranged into four strings, whereinthe one or more memory devices each include SLC memory and MLC memory; acontroller coupled to the one or more memory devices, the controllerconfigured to: write data to the SLC memory of a first string on a firstword line for a first set of dies; foggy write data to the MLC memory ofthe first string on the first word line for the first set of dies; writedata to the SLC memory of a second string on the first word line for thefirst set of dies; foggy write data to the MLC memory of the secondstring on the first word line for the first set of dies; write data tothe SLC memory of a third string on the first word line for the firstset of dies; foggy write data to the MLC memory of the third string onthe first word line for the first set of dies; write data to the SLCmemory of the first string on the first word line for a second set ofdies different from the first set of dies; foggy write data to the MLCmemory of the first string on the first word line for the second set ofdies; write data to the SLC memory of a fourth string on the first wordline for the first set of dies; and foggy write data to the MLC memoryof the fourth string on the first word line for the first set of dies.The writing data to the SLC memory of the first string on teh first wordline for the second set of dies occurs simultaneous with the foggywriting data to the MLC memory of the third string on the first wordline for the first set of dies. The controller is further configured to:write data to the SLC memory of the second string on the first word linefor the second set of dies; foggy write data to the MLC memory of thesecond string on the first word line for the second set of dies; andfine write data to the MLC memory of the first string of a differentword line from the first word line and the second word line for thefirst set of dies. The one or more memory devices each have four XORparity contexts. The one or more memory devices comprises two memorydevices and wherein writing to SLC memory is staggered across the twomemory devices. There is a time gap between starting an SLC writing on astring in a first memory device of the two memory devices and a stringin a second memory device of the two memory devices.

By foggy writing data in MLC that has been stored in latches in thememory device, improved foggy-fine programming occurs. Additionally, byprogramming in a staggered fashion at a ratio of 4:1:1, efficient XORcontext management occurs.

While the foregoing is directed to embodiments of the presentdisclosure, other and further embodiments of the disclosure may bedevised without departing from the basic scope thereof, and the scopethereof is determined by the claims that follow.

1. A data storage device, comprising: one or more memory devices, theone or more memory devices including SLC memory and MLC memory; and acontroller coupled to the one or more memory devices, the controllerconfigured to: write data to the SLC memory; foggy write the data to MLCmemory, wherein the foggy writing the data to the MLC memory includes:retrieving the data from the SLC memory; and writing the retrieved datato the MLC memory; and fine writing the data to the MLC memory.
 2. Thedata storage device of claim 1, wherein the data that is finely writtento the MLC memory does not pass through the SLC memory.
 3. The datastorage device of claim 2, wherein the data that is finely written tothe MLC memory passes through DRAM and an encoder before being finelywritten in the MLC memory.
 4. The data storage device of claim 3,wherein the data written to the SLC memory passes through an encoder. 5.The data storage device of claim 4, wherein the data that is written tothe SLC memory does not pass through the DRAM that the data finelywritten to the MLC memory passes through.
 6. The data storage device ofclaim 5, wherein the data that is foggy written to the MLC memory doesnot pass through the DRAM that the data finely written to the MLC memorypasses through.
 7. The data storage device of claim 1, wherein a singlefour page transfer is used for both the writing the data to the SLCmemory and foggy writing the data to the MLC memory.
 8. A data storagedevice, comprising: one or more memory devices, the one or more memorydevices each including a plurality of dies with each die including SLCmemory and MLC memory; and a controller coupled to the one or morememory devices, the controller configured to: stagger writing to the SLCmemory, foggy writing to the MLC memory, and fine writing to the MLCmemory, wherein a ratio of writing to the SLC memory to foggy writing tothe MLC memory to fine writing to the MLC memory is 4:1:1.
 9. The datastorage device of claim 8, wherein writing to the SLC memory occurs ononly one word line at a time for a given memory device of the one ormore memory devices.
 10. The data storage device of claim 8, whereinfoggy writing to the MLC memory occurs with for multiple word linessimultaneously.
 11. The data storage device of claim 10, whereinsimultaneous foggy writing occurs for different dies.
 12. The datastorage device of claim 11, wherein the simultaneous foggy writingoccurs for the same string.
 13. The data storage device of claim 12,wherein the MLC memory is QLC memory.
 14. The data storage device ofclaim 8, wherein the controller is configured to write data to the SLCmemory of at least a first memory device of the one or more memorydevices simultaneous with foggy writing data to the MLC memory of asecond memory device of the one or more memory devices and simultaneouswith fine writing data to the MLC memory of at least a third memorydevice of the one or more memory devices.
 15. A data storage device,comprising: one or more memory devices, wherein each memory device has aplurality of dies, wherein the plurality of dies are arranged into fourstrings, wherein the one or more memory devices each include SLC memoryand MLC memory; a controller coupled to the one or more memory devices,the controller configured to: write data to the SLC memory of a firststring on a first word line for a first set of dies; foggy write data tothe MLC memory of the first string on the first word line for the firstset of dies; write data to the SLC memory of a second string on thefirst word line for the first set of dies; foggy write data to the MLCmemory of the second string on the first word line for the first set ofdies; write data to the SLC memory of a third string on the first wordline for the first set of dies; foggy write data to the MLC memory ofthe third string on the first word line for the first set of dies; writedata to the SLC memory of the first string on the first word line for asecond set of dies different from the first set of dies; foggy writedata to the MLC memory of the first string on the first word line forthe second set of dies; write data to the SLC memory of a fourth stringon the first word line for the first set of dies; and foggy write datato the MLC memory of the fourth string on the first word line for thefirst set of dies.
 16. The data storage device of claim 15, wherein thewriting data to the SLC memory of the first string on the first wordline for the second set of dies occurs simultaneous with the foggywriting data to the MLC memory of the third string on the first wordline for the first set of dies.
 17. The data storage device of claim 15,wherein the controller is further configured to: write data to the SLCmemory of the second string on the first word line for the second set ofdies; foggy write data to the MLC memory of the second string on thefirst word line for the second set of dies; and fine write data to theMLC memory of the first string of a different word line from the firstword line and the second word line for the first set of dies.
 18. Thedata storage device of claim 15, wherein the one or more memory deviceseach have four XOR parity contexts.
 19. The data storage device of claim15, wherein the one or more memory devices comprises two memory devicesand wherein writing to SLC memory is staggered across the two memorydevices.
 20. The data storage device of claim 19, where there is a timegap between starting an SLC writing on a string in a first memory deviceof the two memory devices and a string in a second memory device of thetwo memory devices.